
\documentclass[12pt]{article}
\usepackage{graphicx}
\pagestyle{empty}
\setcounter{secnumdepth}{2}

\topmargin=0cm
\oddsidemargin=0cm
\textheight=22.0cm
\textwidth=16cm
\parindent=0cm
\parskip=0.15cm
\topskip=0truecm
\raggedbottom
\abovedisplayskip=3mm
\belowdisplayskip=3mm
\abovedisplayshortskip=0mm
\belowdisplayshortskip=2mm
\normalbaselineskip=12pt
\normalbaselines

\begin{document}

\vspace*{0.5in}
\centerline{\bf\Large Design Document}

\vspace*{0.5in}
\centerline{\bf\Large Team X}

\vspace*{0.5in}
\centerline{\bf\Large 7 february 2012}

\vspace*{1.5in}
\begin{table}[htbp]
\caption{Team}
\begin{center}
\begin{tabular}{|r | c|}
\hline
Name & ID Number \\
\hline\hline
X & Y \\
\hline
\end{tabular}
\end{center}
\end{table}

\clearpage

\section{Introduction}

The introduction of the document provides an overview of the entire document,
briefly introducing what are its goals, and what information is to be found in it.

\section{Architectural Design} \label{sec:arch}

This section must give a high-level description of the system in terms of its modules
and their respective purpose and exact interfaces.

\subsection{Architectural Diagram}

A UML class diagram or package diagram depicting the high-level structure of the system,
accompanied by a one-paragraph text describing the rationale of this design.
It is mandatory that the system be divided into at least two subsystems,
and that the purpose of each of these subsystems be exposed here.

\subsection{Subsystem Interface Specifications}

Specification of the software interfaces between the subsystems,
i.e. specific messages (or function calls) that are exchanged by the subsystems.
These are also often called ``Module Interface Specifications''.
Description of the parameters to be passed into these function calls in order to have a service fulfilled,
including valid and invalid ranges of values.
Each subsystem interface must be presented in a separate subsection.

\section{Detailed Design} \label{sec:detail}

The purpose of this system is to read a text file containing tasks and process it. it will read the task id, the title
of the task, a detailed description of what to do, the duration of the task, what needs to be handed in, the deadline and
the person this task is to be done by. This system will register all the information into a list for a others to access.

\subsection{Subsystem FileInput}
\subsubsection{Detailed Design Diagram}
\includegraphics[scale=0.5]{soen1}

The first subsystem has three components. The first section is the Taskman.java. This program's function is to take in which
text file to read and process. It also check to make sure that the file exist and will return an error message if the file
is no present. The second section is the FileInput.java. This program's function is to process the text file. It will read each
line in the text file and put it in a list in the system. The last section is the Task.java. This program is the object that
will take in the information of a task. It also has some get and set function so individual variable can be modified.

This design was chosen because it is easy for any programmer to read and it is secure. The system is divided into 3 part so
so that each section will have individual task to accomplish. By putting all the function into a single program would have
been too cluttered and would have had too much information all at once. By separating certain functionality into different
programs, it becomes easier to read. Another reason for separating the functions is to add security. Since Taskman.java called
to find the text file and send it to be processed, many people would use it to process many different files. Since FileInput.java
is the program that will process all the data, only certain people would be allowed to work on it. By separating Taskman.java
and FileInput.java, we can set different permissions so that only certain individuals can work with FileInput.java. Finally,
Task.Java is an object class that is used to store individual task. It is conventional to put in into its own section.


\subsubsection{Units Description}

Taskman.java:
	Program takes in the text file to be processed. If no text file name is given, the default text file to process is called
	input.txt
	
FileInput.java:
	Processes the text file and put it into an array list
	
	resetVars: Function initialises all the variables
	loadFromFile: Function reads each line of the text file and place it into the apropiate variable
	export: Function adds the task into the array list
		
Task.java:
	Object class that hold all the information
	
	getId/setId: get/set id
	getTitle/setTitle: get/set title
	getDescripption/setDescription: get/set Description
	getDuration/setDuration: get/set Duration
	getDeliverable/setDeliverable: get/set Deliverable
	getDeadline/setDeadline: get/set Deadline
	getPersonId/setPersonId: get/set the person tasked for this job
	toString: output the task, the description and the person responsible for this task
	
\section{Dynamic Design Scenarios}

\includegraphics[scale=0.8]{soen3}

Scenario 1:
File is sent to Taskman.java for processing. It reads the file, sends the information to FileInput.java to process.
FileInput reads each lines and place the information in a placeholder variable. After all the information for a task is read,
It place all the information in a task object which then places it in a list. The loop continues until the end of the file.


\includegraphics[scale=0.8]{soen4}

Scenario 2:
User uses TasksManagementWindow.Java to check up on all the information of a task using the task ID
\end{document}
